//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS ChimeSDKMediaPipelines service.
///
/// The Amazon Chime SDK media pipeline APIs in this section allow software developers to create Amazon Chime SDK media pipelines that capture, concatenate, or stream your Amazon Chime SDK meetings. For more information about media pipelines, see Amazon Chime SDK media pipelines.
public struct ChimeSDKMediaPipelines: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the ChimeSDKMediaPipelines client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "ChimeSDKMediaPipelines",
            serviceIdentifier: "media-pipelines-chime",
            signingName: "chime",
            serviceProtocol: .restjson,
            apiVersion: "2021-07-15",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: ChimeSDKMediaPipelinesErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-east-1": "media-pipelines-chime-fips.us-east-1.amazonaws.com",
            "us-west-2": "media-pipelines-chime-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Creates a media pipeline.
    @Sendable
    @inlinable
    public func createMediaCapturePipeline(_ input: CreateMediaCapturePipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMediaCapturePipelineResponse {
        try await self.client.execute(
            operation: "CreateMediaCapturePipeline", 
            path: "/sdk-media-capture-pipelines", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a media pipeline.
    ///
    /// Parameters:
    ///   - chimeSdkMeetingConfiguration: The configuration for a specified media pipeline. SourceType must be ChimeSdkMeeting.
    ///   - clientRequestToken: The unique identifier for the client request. The token makes the API request idempotent. Use a unique token for each media pipeline request.
    ///   - sinkArn: The ARN of the sink type.
    ///   - sinkIamRoleArn: The Amazon Resource Name (ARN) of the sink role to be used with AwsKmsKeyId in SseAwsKeyManagementParams. Can only interact with S3Bucket sink type. The role must belong to the caller’s account and be able to act on behalf of the caller during the API call. All minimum policy permissions requirements for the caller to perform sink-related actions are the same for SinkIamRoleArn. Additionally, the role must have permission to kms:GenerateDataKey using KMS key supplied as AwsKmsKeyId in SseAwsKeyManagementParams. If media concatenation will be required later, the role must also have permission to kms:Decrypt for the same KMS key.
    ///   - sinkType: Destination type to which the media artifacts are saved. You must use an S3 bucket.
    ///   - sourceArn: ARN of the source from which the media artifacts are captured.
    ///   - sourceType: Source type from which the media artifacts are captured. A Chime SDK Meeting is the only supported source.
    ///   - sseAwsKeyManagementParams: An object that contains server side encryption parameters to be used by media capture pipeline. The parameters can also be used by media concatenation pipeline taking media capture pipeline as a media source.
    ///   - tags: The tag key-value pairs.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMediaCapturePipeline(
        chimeSdkMeetingConfiguration: ChimeSdkMeetingConfiguration? = nil,
        clientRequestToken: String? = CreateMediaCapturePipelineRequest.idempotencyToken(),
        sinkArn: String,
        sinkIamRoleArn: String? = nil,
        sinkType: MediaPipelineSinkType,
        sourceArn: String,
        sourceType: MediaPipelineSourceType,
        sseAwsKeyManagementParams: SseAwsKeyManagementParams? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMediaCapturePipelineResponse {
        let input = CreateMediaCapturePipelineRequest(
            chimeSdkMeetingConfiguration: chimeSdkMeetingConfiguration, 
            clientRequestToken: clientRequestToken, 
            sinkArn: sinkArn, 
            sinkIamRoleArn: sinkIamRoleArn, 
            sinkType: sinkType, 
            sourceArn: sourceArn, 
            sourceType: sourceType, 
            sseAwsKeyManagementParams: sseAwsKeyManagementParams, 
            tags: tags
        )
        return try await self.createMediaCapturePipeline(input, logger: logger)
    }

    /// Creates a media concatenation pipeline.
    @Sendable
    @inlinable
    public func createMediaConcatenationPipeline(_ input: CreateMediaConcatenationPipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMediaConcatenationPipelineResponse {
        try await self.client.execute(
            operation: "CreateMediaConcatenationPipeline", 
            path: "/sdk-media-concatenation-pipelines", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a media concatenation pipeline.
    ///
    /// Parameters:
    ///   - clientRequestToken: The unique identifier for the client request. The token makes the API request idempotent. Use a unique token for each media concatenation pipeline request.
    ///   - sinks: An object that specifies the data sinks for the media concatenation pipeline.
    ///   - sources: An object that specifies the sources for the media concatenation pipeline.
    ///   - tags: The tags associated with the media concatenation pipeline.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMediaConcatenationPipeline(
        clientRequestToken: String? = CreateMediaConcatenationPipelineRequest.idempotencyToken(),
        sinks: [ConcatenationSink],
        sources: [ConcatenationSource],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMediaConcatenationPipelineResponse {
        let input = CreateMediaConcatenationPipelineRequest(
            clientRequestToken: clientRequestToken, 
            sinks: sinks, 
            sources: sources, 
            tags: tags
        )
        return try await self.createMediaConcatenationPipeline(input, logger: logger)
    }

    /// Creates a media insights pipeline.
    @Sendable
    @inlinable
    public func createMediaInsightsPipeline(_ input: CreateMediaInsightsPipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMediaInsightsPipelineResponse {
        try await self.client.execute(
            operation: "CreateMediaInsightsPipeline", 
            path: "/media-insights-pipelines", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a media insights pipeline.
    ///
    /// Parameters:
    ///   - clientRequestToken: The unique identifier for the media insights pipeline request.
    ///   - kinesisVideoStreamRecordingSourceRuntimeConfiguration: The runtime configuration for the Kinesis video recording stream source.
    ///   - kinesisVideoStreamSourceRuntimeConfiguration: The runtime configuration for the Kinesis video stream source of the media insights pipeline.
    ///   - mediaInsightsPipelineConfigurationArn: The ARN of the pipeline's configuration.
    ///   - mediaInsightsRuntimeMetadata: The runtime metadata for the media insights pipeline. Consists of a key-value map of strings.
    ///   - s3RecordingSinkRuntimeConfiguration: The runtime configuration for the S3 recording sink. If specified, the settings in this structure override any settings in S3RecordingSinkConfiguration.
    ///   - tags: The tags assigned to the media insights pipeline.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMediaInsightsPipeline(
        clientRequestToken: String? = CreateMediaInsightsPipelineRequest.idempotencyToken(),
        kinesisVideoStreamRecordingSourceRuntimeConfiguration: KinesisVideoStreamRecordingSourceRuntimeConfiguration? = nil,
        kinesisVideoStreamSourceRuntimeConfiguration: KinesisVideoStreamSourceRuntimeConfiguration? = nil,
        mediaInsightsPipelineConfigurationArn: String,
        mediaInsightsRuntimeMetadata: [String: String]? = nil,
        s3RecordingSinkRuntimeConfiguration: S3RecordingSinkRuntimeConfiguration? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMediaInsightsPipelineResponse {
        let input = CreateMediaInsightsPipelineRequest(
            clientRequestToken: clientRequestToken, 
            kinesisVideoStreamRecordingSourceRuntimeConfiguration: kinesisVideoStreamRecordingSourceRuntimeConfiguration, 
            kinesisVideoStreamSourceRuntimeConfiguration: kinesisVideoStreamSourceRuntimeConfiguration, 
            mediaInsightsPipelineConfigurationArn: mediaInsightsPipelineConfigurationArn, 
            mediaInsightsRuntimeMetadata: mediaInsightsRuntimeMetadata, 
            s3RecordingSinkRuntimeConfiguration: s3RecordingSinkRuntimeConfiguration, 
            tags: tags
        )
        return try await self.createMediaInsightsPipeline(input, logger: logger)
    }

    /// A structure that contains the static configurations for a media insights pipeline.
    @Sendable
    @inlinable
    public func createMediaInsightsPipelineConfiguration(_ input: CreateMediaInsightsPipelineConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMediaInsightsPipelineConfigurationResponse {
        try await self.client.execute(
            operation: "CreateMediaInsightsPipelineConfiguration", 
            path: "/media-insights-pipeline-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A structure that contains the static configurations for a media insights pipeline.
    ///
    /// Parameters:
    ///   - clientRequestToken: The unique identifier for the media insights pipeline configuration request.
    ///   - elements: The elements in the request, such as a processor for Amazon Transcribe or a sink for a Kinesis Data Stream.
    ///   - mediaInsightsPipelineConfigurationName: The name of the media insights pipeline configuration.
    ///   - realTimeAlertConfiguration: The configuration settings for the real-time alerts in a media insights pipeline configuration.
    ///   - resourceAccessRoleArn: The ARN of the role used by the service to access Amazon Web Services resources, including Transcribe and Transcribe Call Analytics, on the  caller’s behalf.
    ///   - tags: The tags assigned to the media insights pipeline configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMediaInsightsPipelineConfiguration(
        clientRequestToken: String? = CreateMediaInsightsPipelineConfigurationRequest.idempotencyToken(),
        elements: [MediaInsightsPipelineConfigurationElement],
        mediaInsightsPipelineConfigurationName: String,
        realTimeAlertConfiguration: RealTimeAlertConfiguration? = nil,
        resourceAccessRoleArn: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMediaInsightsPipelineConfigurationResponse {
        let input = CreateMediaInsightsPipelineConfigurationRequest(
            clientRequestToken: clientRequestToken, 
            elements: elements, 
            mediaInsightsPipelineConfigurationName: mediaInsightsPipelineConfigurationName, 
            realTimeAlertConfiguration: realTimeAlertConfiguration, 
            resourceAccessRoleArn: resourceAccessRoleArn, 
            tags: tags
        )
        return try await self.createMediaInsightsPipelineConfiguration(input, logger: logger)
    }

    /// Creates a media live connector pipeline in an Amazon Chime SDK meeting.
    @Sendable
    @inlinable
    public func createMediaLiveConnectorPipeline(_ input: CreateMediaLiveConnectorPipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMediaLiveConnectorPipelineResponse {
        try await self.client.execute(
            operation: "CreateMediaLiveConnectorPipeline", 
            path: "/sdk-media-live-connector-pipelines", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a media live connector pipeline in an Amazon Chime SDK meeting.
    ///
    /// Parameters:
    ///   - clientRequestToken: The token assigned to the client making the request.
    ///   - sinks: The media live connector pipeline's data sinks.
    ///   - sources: The media live connector pipeline's data sources.
    ///   - tags: The tags associated with the media live connector pipeline.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMediaLiveConnectorPipeline(
        clientRequestToken: String? = CreateMediaLiveConnectorPipelineRequest.idempotencyToken(),
        sinks: [LiveConnectorSinkConfiguration],
        sources: [LiveConnectorSourceConfiguration],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMediaLiveConnectorPipelineResponse {
        let input = CreateMediaLiveConnectorPipelineRequest(
            clientRequestToken: clientRequestToken, 
            sinks: sinks, 
            sources: sources, 
            tags: tags
        )
        return try await self.createMediaLiveConnectorPipeline(input, logger: logger)
    }

    /// Creates an Amazon Kinesis Video Stream pool for use with media stream pipelines.  If a meeting uses an opt-in Region as its   MediaRegion,  the KVS stream must be in that same Region. For example, if a meeting uses the af-south-1 Region, the KVS stream must also be in af-south-1. However, if the meeting uses a  Region that AWS turns on by default, the KVS stream can be in any available Region, including an opt-in Region. For example, if the meeting uses ca-central-1, the KVS stream can be in  eu-west-2, us-east-1, af-south-1, or any other Region that the Amazon Chime SDK supports. To learn  which AWS Region a meeting uses, call the GetMeeting API and  use the MediaRegion  parameter from the response. For more information about opt-in Regions, refer to Available Regions in the  Amazon Chime SDK Developer Guide, and  Specify which AWS Regions your account can use,  in the AWS Account Management Reference Guide.
    @Sendable
    @inlinable
    public func createMediaPipelineKinesisVideoStreamPool(_ input: CreateMediaPipelineKinesisVideoStreamPoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMediaPipelineKinesisVideoStreamPoolResponse {
        try await self.client.execute(
            operation: "CreateMediaPipelineKinesisVideoStreamPool", 
            path: "/media-pipeline-kinesis-video-stream-pools", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Kinesis Video Stream pool for use with media stream pipelines.  If a meeting uses an opt-in Region as its   MediaRegion,  the KVS stream must be in that same Region. For example, if a meeting uses the af-south-1 Region, the KVS stream must also be in af-south-1. However, if the meeting uses a  Region that AWS turns on by default, the KVS stream can be in any available Region, including an opt-in Region. For example, if the meeting uses ca-central-1, the KVS stream can be in  eu-west-2, us-east-1, af-south-1, or any other Region that the Amazon Chime SDK supports. To learn  which AWS Region a meeting uses, call the GetMeeting API and  use the MediaRegion  parameter from the response. For more information about opt-in Regions, refer to Available Regions in the  Amazon Chime SDK Developer Guide, and  Specify which AWS Regions your account can use,  in the AWS Account Management Reference Guide.
    ///
    /// Parameters:
    ///   - clientRequestToken: The token assigned to the client making the request.
    ///   - poolName: The name of the pool.
    ///   - streamConfiguration: The configuration settings for the stream.
    ///   - tags: The tags assigned to the stream pool.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMediaPipelineKinesisVideoStreamPool(
        clientRequestToken: String? = CreateMediaPipelineKinesisVideoStreamPoolRequest.idempotencyToken(),
        poolName: String,
        streamConfiguration: KinesisVideoStreamConfiguration,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMediaPipelineKinesisVideoStreamPoolResponse {
        let input = CreateMediaPipelineKinesisVideoStreamPoolRequest(
            clientRequestToken: clientRequestToken, 
            poolName: poolName, 
            streamConfiguration: streamConfiguration, 
            tags: tags
        )
        return try await self.createMediaPipelineKinesisVideoStreamPool(input, logger: logger)
    }

    /// Creates a streaming media pipeline.
    @Sendable
    @inlinable
    public func createMediaStreamPipeline(_ input: CreateMediaStreamPipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMediaStreamPipelineResponse {
        try await self.client.execute(
            operation: "CreateMediaStreamPipeline", 
            path: "/sdk-media-stream-pipelines", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a streaming media pipeline.
    ///
    /// Parameters:
    ///   - clientRequestToken: The token assigned to the client making the request.
    ///   - sinks: The data sink for the media pipeline.
    ///   - sources: The data sources for the media pipeline.
    ///   - tags: The tags assigned to the media pipeline.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMediaStreamPipeline(
        clientRequestToken: String? = CreateMediaStreamPipelineRequest.idempotencyToken(),
        sinks: [MediaStreamSink],
        sources: [MediaStreamSource],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMediaStreamPipelineResponse {
        let input = CreateMediaStreamPipelineRequest(
            clientRequestToken: clientRequestToken, 
            sinks: sinks, 
            sources: sources, 
            tags: tags
        )
        return try await self.createMediaStreamPipeline(input, logger: logger)
    }

    /// Deletes the media pipeline.
    @Sendable
    @inlinable
    public func deleteMediaCapturePipeline(_ input: DeleteMediaCapturePipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteMediaCapturePipeline", 
            path: "/sdk-media-capture-pipelines/{MediaPipelineId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the media pipeline.
    ///
    /// Parameters:
    ///   - mediaPipelineId: The ID of the media pipeline being deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMediaCapturePipeline(
        mediaPipelineId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteMediaCapturePipelineRequest(
            mediaPipelineId: mediaPipelineId
        )
        return try await self.deleteMediaCapturePipeline(input, logger: logger)
    }

    /// Deletes the specified configuration settings.
    @Sendable
    @inlinable
    public func deleteMediaInsightsPipelineConfiguration(_ input: DeleteMediaInsightsPipelineConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteMediaInsightsPipelineConfiguration", 
            path: "/media-insights-pipeline-configurations/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified configuration settings.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the resource to be deleted. Valid values include the name and ARN of the media insights pipeline configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMediaInsightsPipelineConfiguration(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteMediaInsightsPipelineConfigurationRequest(
            identifier: identifier
        )
        return try await self.deleteMediaInsightsPipelineConfiguration(input, logger: logger)
    }

    /// Deletes the media pipeline.
    @Sendable
    @inlinable
    public func deleteMediaPipeline(_ input: DeleteMediaPipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteMediaPipeline", 
            path: "/sdk-media-pipelines/{MediaPipelineId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the media pipeline.
    ///
    /// Parameters:
    ///   - mediaPipelineId: The ID of the media pipeline to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMediaPipeline(
        mediaPipelineId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteMediaPipelineRequest(
            mediaPipelineId: mediaPipelineId
        )
        return try await self.deleteMediaPipeline(input, logger: logger)
    }

    /// Deletes an Amazon Kinesis Video Stream pool.
    @Sendable
    @inlinable
    public func deleteMediaPipelineKinesisVideoStreamPool(_ input: DeleteMediaPipelineKinesisVideoStreamPoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteMediaPipelineKinesisVideoStreamPool", 
            path: "/media-pipeline-kinesis-video-stream-pools/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Kinesis Video Stream pool.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the requested resource. Valid values include the name and ARN of the media pipeline Kinesis Video Stream pool.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMediaPipelineKinesisVideoStreamPool(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteMediaPipelineKinesisVideoStreamPoolRequest(
            identifier: identifier
        )
        return try await self.deleteMediaPipelineKinesisVideoStreamPool(input, logger: logger)
    }

    /// Gets an existing media pipeline.
    @Sendable
    @inlinable
    public func getMediaCapturePipeline(_ input: GetMediaCapturePipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMediaCapturePipelineResponse {
        try await self.client.execute(
            operation: "GetMediaCapturePipeline", 
            path: "/sdk-media-capture-pipelines/{MediaPipelineId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an existing media pipeline.
    ///
    /// Parameters:
    ///   - mediaPipelineId: The ID of the pipeline that you want to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMediaCapturePipeline(
        mediaPipelineId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMediaCapturePipelineResponse {
        let input = GetMediaCapturePipelineRequest(
            mediaPipelineId: mediaPipelineId
        )
        return try await self.getMediaCapturePipeline(input, logger: logger)
    }

    /// Gets the configuration settings for a media insights pipeline.
    @Sendable
    @inlinable
    public func getMediaInsightsPipelineConfiguration(_ input: GetMediaInsightsPipelineConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMediaInsightsPipelineConfigurationResponse {
        try await self.client.execute(
            operation: "GetMediaInsightsPipelineConfiguration", 
            path: "/media-insights-pipeline-configurations/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the configuration settings for a media insights pipeline.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the requested resource.  Valid values include the name and ARN of the media insights pipeline configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMediaInsightsPipelineConfiguration(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMediaInsightsPipelineConfigurationResponse {
        let input = GetMediaInsightsPipelineConfigurationRequest(
            identifier: identifier
        )
        return try await self.getMediaInsightsPipelineConfiguration(input, logger: logger)
    }

    /// Gets an existing media pipeline.
    @Sendable
    @inlinable
    public func getMediaPipeline(_ input: GetMediaPipelineRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMediaPipelineResponse {
        try await self.client.execute(
            operation: "GetMediaPipeline", 
            path: "/sdk-media-pipelines/{MediaPipelineId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an existing media pipeline.
    ///
    /// Parameters:
    ///   - mediaPipelineId: The ID of the pipeline that you want to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMediaPipeline(
        mediaPipelineId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMediaPipelineResponse {
        let input = GetMediaPipelineRequest(
            mediaPipelineId: mediaPipelineId
        )
        return try await self.getMediaPipeline(input, logger: logger)
    }

    /// Gets an Kinesis video stream pool.
    @Sendable
    @inlinable
    public func getMediaPipelineKinesisVideoStreamPool(_ input: GetMediaPipelineKinesisVideoStreamPoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMediaPipelineKinesisVideoStreamPoolResponse {
        try await self.client.execute(
            operation: "GetMediaPipelineKinesisVideoStreamPool", 
            path: "/media-pipeline-kinesis-video-stream-pools/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an Kinesis video stream pool.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the requested resource. Valid values include the name and ARN of the media pipeline Kinesis Video Stream pool.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMediaPipelineKinesisVideoStreamPool(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMediaPipelineKinesisVideoStreamPoolResponse {
        let input = GetMediaPipelineKinesisVideoStreamPoolRequest(
            identifier: identifier
        )
        return try await self.getMediaPipelineKinesisVideoStreamPool(input, logger: logger)
    }

    /// Retrieves the details of the specified speaker search task.
    @Sendable
    @inlinable
    public func getSpeakerSearchTask(_ input: GetSpeakerSearchTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSpeakerSearchTaskResponse {
        try await self.client.execute(
            operation: "GetSpeakerSearchTask", 
            path: "/media-insights-pipelines/{Identifier}/speaker-search-tasks/{SpeakerSearchTaskId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the details of the specified speaker search task.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the resource to be updated. Valid values include the ID and ARN of the media insights pipeline.
    ///   - speakerSearchTaskId: The ID of the speaker search task.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSpeakerSearchTask(
        identifier: String,
        speakerSearchTaskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSpeakerSearchTaskResponse {
        let input = GetSpeakerSearchTaskRequest(
            identifier: identifier, 
            speakerSearchTaskId: speakerSearchTaskId
        )
        return try await self.getSpeakerSearchTask(input, logger: logger)
    }

    /// Retrieves the details of a voice tone analysis task.
    @Sendable
    @inlinable
    public func getVoiceToneAnalysisTask(_ input: GetVoiceToneAnalysisTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetVoiceToneAnalysisTaskResponse {
        try await self.client.execute(
            operation: "GetVoiceToneAnalysisTask", 
            path: "/media-insights-pipelines/{Identifier}/voice-tone-analysis-tasks/{VoiceToneAnalysisTaskId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the details of a voice tone analysis task.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the resource to be updated. Valid values include the ID and ARN of the media insights pipeline.
    ///   - voiceToneAnalysisTaskId: The ID of the voice tone analysis task.
    ///   - logger: Logger use during operation
    @inlinable
    public func getVoiceToneAnalysisTask(
        identifier: String,
        voiceToneAnalysisTaskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetVoiceToneAnalysisTaskResponse {
        let input = GetVoiceToneAnalysisTaskRequest(
            identifier: identifier, 
            voiceToneAnalysisTaskId: voiceToneAnalysisTaskId
        )
        return try await self.getVoiceToneAnalysisTask(input, logger: logger)
    }

    /// Returns a list of media pipelines.
    @Sendable
    @inlinable
    public func listMediaCapturePipelines(_ input: ListMediaCapturePipelinesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMediaCapturePipelinesResponse {
        try await self.client.execute(
            operation: "ListMediaCapturePipelines", 
            path: "/sdk-media-capture-pipelines", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of media pipelines.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Valid Range: 1 - 99.
    ///   - nextToken: The token used to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMediaCapturePipelines(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMediaCapturePipelinesResponse {
        let input = ListMediaCapturePipelinesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMediaCapturePipelines(input, logger: logger)
    }

    /// Lists the available media insights pipeline configurations.
    @Sendable
    @inlinable
    public func listMediaInsightsPipelineConfigurations(_ input: ListMediaInsightsPipelineConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMediaInsightsPipelineConfigurationsResponse {
        try await self.client.execute(
            operation: "ListMediaInsightsPipelineConfigurations", 
            path: "/media-insights-pipeline-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the available media insights pipeline configurations.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: The token used to return the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMediaInsightsPipelineConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMediaInsightsPipelineConfigurationsResponse {
        let input = ListMediaInsightsPipelineConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMediaInsightsPipelineConfigurations(input, logger: logger)
    }

    /// Lists the video stream pools in the media pipeline.
    @Sendable
    @inlinable
    public func listMediaPipelineKinesisVideoStreamPools(_ input: ListMediaPipelineKinesisVideoStreamPoolsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMediaPipelineKinesisVideoStreamPoolsResponse {
        try await self.client.execute(
            operation: "ListMediaPipelineKinesisVideoStreamPools", 
            path: "/media-pipeline-kinesis-video-stream-pools", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the video stream pools in the media pipeline.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: The token used to return the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMediaPipelineKinesisVideoStreamPools(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMediaPipelineKinesisVideoStreamPoolsResponse {
        let input = ListMediaPipelineKinesisVideoStreamPoolsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMediaPipelineKinesisVideoStreamPools(input, logger: logger)
    }

    /// Returns a list of media pipelines.
    @Sendable
    @inlinable
    public func listMediaPipelines(_ input: ListMediaPipelinesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMediaPipelinesResponse {
        try await self.client.execute(
            operation: "ListMediaPipelines", 
            path: "/sdk-media-pipelines", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of media pipelines.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Valid Range: 1 - 99.
    ///   - nextToken: The token used to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMediaPipelines(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMediaPipelinesResponse {
        let input = ListMediaPipelinesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMediaPipelines(input, logger: logger)
    }

    /// Lists the tags available for a media pipeline.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags available for a media pipeline.
    ///
    /// Parameters:
    ///   - resourceARN: The ARN of the media pipeline associated with any tags. The ARN consists of the pipeline's region, resource ID, and pipeline ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceARN: resourceARN
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Starts a speaker search task.  Before starting any speaker search tasks, you must provide all notices and obtain all consents from the speaker as required under applicable privacy and biometrics laws, and as required under the AWS service terms for the Amazon Chime SDK.
    @Sendable
    @inlinable
    public func startSpeakerSearchTask(_ input: StartSpeakerSearchTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartSpeakerSearchTaskResponse {
        try await self.client.execute(
            operation: "StartSpeakerSearchTask", 
            path: "/media-insights-pipelines/{Identifier}/speaker-search-tasks?operation=start", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a speaker search task.  Before starting any speaker search tasks, you must provide all notices and obtain all consents from the speaker as required under applicable privacy and biometrics laws, and as required under the AWS service terms for the Amazon Chime SDK.
    ///
    /// Parameters:
    ///   - clientRequestToken: The unique identifier for the client request. Use a different token for different speaker search tasks.
    ///   - identifier: The unique identifier of the resource to be updated. Valid values include the ID and ARN of the media insights pipeline.
    ///   - kinesisVideoStreamSourceTaskConfiguration: The task configuration for the Kinesis video stream source of the media insights pipeline.
    ///   - voiceProfileDomainArn: The ARN of the voice profile domain that will store the voice profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func startSpeakerSearchTask(
        clientRequestToken: String? = StartSpeakerSearchTaskRequest.idempotencyToken(),
        identifier: String,
        kinesisVideoStreamSourceTaskConfiguration: KinesisVideoStreamSourceTaskConfiguration? = nil,
        voiceProfileDomainArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartSpeakerSearchTaskResponse {
        let input = StartSpeakerSearchTaskRequest(
            clientRequestToken: clientRequestToken, 
            identifier: identifier, 
            kinesisVideoStreamSourceTaskConfiguration: kinesisVideoStreamSourceTaskConfiguration, 
            voiceProfileDomainArn: voiceProfileDomainArn
        )
        return try await self.startSpeakerSearchTask(input, logger: logger)
    }

    /// Starts a voice tone analysis task. For more information about voice tone analysis, see Using Amazon Chime SDK voice analytics in the Amazon Chime SDK Developer Guide.  Before starting any voice tone analysis tasks, you must provide all notices and obtain all consents from the speaker as required under applicable privacy and biometrics laws, and as required under the AWS service terms for the Amazon Chime SDK.
    @Sendable
    @inlinable
    public func startVoiceToneAnalysisTask(_ input: StartVoiceToneAnalysisTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartVoiceToneAnalysisTaskResponse {
        try await self.client.execute(
            operation: "StartVoiceToneAnalysisTask", 
            path: "/media-insights-pipelines/{Identifier}/voice-tone-analysis-tasks?operation=start", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a voice tone analysis task. For more information about voice tone analysis, see Using Amazon Chime SDK voice analytics in the Amazon Chime SDK Developer Guide.  Before starting any voice tone analysis tasks, you must provide all notices and obtain all consents from the speaker as required under applicable privacy and biometrics laws, and as required under the AWS service terms for the Amazon Chime SDK.
    ///
    /// Parameters:
    ///   - clientRequestToken: The unique identifier for the client request. Use a different token for different voice tone analysis tasks.
    ///   - identifier: The unique identifier of the resource to be updated. Valid values include the ID and ARN of the media insights pipeline.
    ///   - kinesisVideoStreamSourceTaskConfiguration: The task configuration for the Kinesis video stream source of the media insights pipeline.
    ///   - languageCode: The language code.
    ///   - logger: Logger use during operation
    @inlinable
    public func startVoiceToneAnalysisTask(
        clientRequestToken: String? = StartVoiceToneAnalysisTaskRequest.idempotencyToken(),
        identifier: String,
        kinesisVideoStreamSourceTaskConfiguration: KinesisVideoStreamSourceTaskConfiguration? = nil,
        languageCode: VoiceAnalyticsLanguageCode,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartVoiceToneAnalysisTaskResponse {
        let input = StartVoiceToneAnalysisTaskRequest(
            clientRequestToken: clientRequestToken, 
            identifier: identifier, 
            kinesisVideoStreamSourceTaskConfiguration: kinesisVideoStreamSourceTaskConfiguration, 
            languageCode: languageCode
        )
        return try await self.startVoiceToneAnalysisTask(input, logger: logger)
    }

    /// Stops a speaker search task.
    @Sendable
    @inlinable
    public func stopSpeakerSearchTask(_ input: StopSpeakerSearchTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "StopSpeakerSearchTask", 
            path: "/media-insights-pipelines/{Identifier}/speaker-search-tasks/{SpeakerSearchTaskId}?operation=stop", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Stops a speaker search task.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the resource to be updated. Valid values include the ID and ARN of the media insights pipeline.
    ///   - speakerSearchTaskId: The speaker search task ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopSpeakerSearchTask(
        identifier: String,
        speakerSearchTaskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = StopSpeakerSearchTaskRequest(
            identifier: identifier, 
            speakerSearchTaskId: speakerSearchTaskId
        )
        return try await self.stopSpeakerSearchTask(input, logger: logger)
    }

    /// Stops a voice tone analysis task.
    @Sendable
    @inlinable
    public func stopVoiceToneAnalysisTask(_ input: StopVoiceToneAnalysisTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "StopVoiceToneAnalysisTask", 
            path: "/media-insights-pipelines/{Identifier}/voice-tone-analysis-tasks/{VoiceToneAnalysisTaskId}?operation=stop", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Stops a voice tone analysis task.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the resource to be updated. Valid values include the ID and ARN of the media insights pipeline.
    ///   - voiceToneAnalysisTaskId: The ID of the voice tone analysis task.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopVoiceToneAnalysisTask(
        identifier: String,
        voiceToneAnalysisTaskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = StopVoiceToneAnalysisTaskRequest(
            identifier: identifier, 
            voiceToneAnalysisTaskId: voiceToneAnalysisTaskId
        )
        return try await self.stopVoiceToneAnalysisTask(input, logger: logger)
    }

    /// The ARN of the media pipeline that you want to tag. Consists of the pipeline's endpoint region, resource ID, and pipeline ID.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags?operation=tag-resource", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// The ARN of the media pipeline that you want to tag. Consists of the pipeline's endpoint region, resource ID, and pipeline ID.
    ///
    /// Parameters:
    ///   - resourceARN: The ARN of the media pipeline associated with any tags. The ARN consists of the pipeline's endpoint region, resource ID, and pipeline ID.
    ///   - tags: The tags associated with the specified media pipeline.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceARN: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceARN: resourceARN, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes any tags from a media pipeline.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags?operation=untag-resource", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes any tags from a media pipeline.
    ///
    /// Parameters:
    ///   - resourceARN: The ARN of the pipeline that you want to untag.
    ///   - tagKeys: The key/value pairs in the tag that you want to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceARN: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceARN: resourceARN, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the media insights pipeline's configuration settings.
    @Sendable
    @inlinable
    public func updateMediaInsightsPipelineConfiguration(_ input: UpdateMediaInsightsPipelineConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMediaInsightsPipelineConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateMediaInsightsPipelineConfiguration", 
            path: "/media-insights-pipeline-configurations/{Identifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the media insights pipeline's configuration settings.
    ///
    /// Parameters:
    ///   - elements: The elements in the request, such as a processor for Amazon Transcribe or a sink for a Kinesis Data Stream..
    ///   - identifier: The unique identifier for the resource to be updated. Valid values include the name and ARN of the media insights pipeline configuration.
    ///   - realTimeAlertConfiguration: The configuration settings for real-time alerts for the media insights pipeline.
    ///   - resourceAccessRoleArn: The ARN of the role used by the service to access Amazon Web Services resources.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMediaInsightsPipelineConfiguration(
        elements: [MediaInsightsPipelineConfigurationElement],
        identifier: String,
        realTimeAlertConfiguration: RealTimeAlertConfiguration? = nil,
        resourceAccessRoleArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMediaInsightsPipelineConfigurationResponse {
        let input = UpdateMediaInsightsPipelineConfigurationRequest(
            elements: elements, 
            identifier: identifier, 
            realTimeAlertConfiguration: realTimeAlertConfiguration, 
            resourceAccessRoleArn: resourceAccessRoleArn
        )
        return try await self.updateMediaInsightsPipelineConfiguration(input, logger: logger)
    }

    /// Updates the status of a media insights pipeline.
    @Sendable
    @inlinable
    public func updateMediaInsightsPipelineStatus(_ input: UpdateMediaInsightsPipelineStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateMediaInsightsPipelineStatus", 
            path: "/media-insights-pipeline-status/{Identifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the status of a media insights pipeline.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the resource to be updated. Valid values include the ID and ARN of the media insights pipeline.
    ///   - updateStatus: The requested status of the media insights pipeline.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMediaInsightsPipelineStatus(
        identifier: String,
        updateStatus: MediaPipelineStatusUpdate,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateMediaInsightsPipelineStatusRequest(
            identifier: identifier, 
            updateStatus: updateStatus
        )
        return try await self.updateMediaInsightsPipelineStatus(input, logger: logger)
    }

    /// Updates an Amazon Kinesis Video Stream pool in a media pipeline.
    @Sendable
    @inlinable
    public func updateMediaPipelineKinesisVideoStreamPool(_ input: UpdateMediaPipelineKinesisVideoStreamPoolRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMediaPipelineKinesisVideoStreamPoolResponse {
        try await self.client.execute(
            operation: "UpdateMediaPipelineKinesisVideoStreamPool", 
            path: "/media-pipeline-kinesis-video-stream-pools/{Identifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Amazon Kinesis Video Stream pool in a media pipeline.
    ///
    /// Parameters:
    ///   - identifier: The unique identifier of the requested resource. Valid values include the name and ARN of the media pipeline Kinesis Video Stream pool.
    ///   - streamConfiguration: The configuration settings for the video stream.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMediaPipelineKinesisVideoStreamPool(
        identifier: String,
        streamConfiguration: KinesisVideoStreamConfigurationUpdate? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMediaPipelineKinesisVideoStreamPoolResponse {
        let input = UpdateMediaPipelineKinesisVideoStreamPoolRequest(
            identifier: identifier, 
            streamConfiguration: streamConfiguration
        )
        return try await self.updateMediaPipelineKinesisVideoStreamPool(input, logger: logger)
    }
}

extension ChimeSDKMediaPipelines {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: ChimeSDKMediaPipelines, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension ChimeSDKMediaPipelines {
    /// Return PaginatorSequence for operation ``listMediaCapturePipelines(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaCapturePipelinesPaginator(
        _ input: ListMediaCapturePipelinesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMediaCapturePipelinesRequest, ListMediaCapturePipelinesResponse> {
        return .init(
            input: input,
            command: self.listMediaCapturePipelines,
            inputKey: \ListMediaCapturePipelinesRequest.nextToken,
            outputKey: \ListMediaCapturePipelinesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMediaCapturePipelines(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Valid Range: 1 - 99.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaCapturePipelinesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMediaCapturePipelinesRequest, ListMediaCapturePipelinesResponse> {
        let input = ListMediaCapturePipelinesRequest(
            maxResults: maxResults
        )
        return self.listMediaCapturePipelinesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMediaInsightsPipelineConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaInsightsPipelineConfigurationsPaginator(
        _ input: ListMediaInsightsPipelineConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMediaInsightsPipelineConfigurationsRequest, ListMediaInsightsPipelineConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listMediaInsightsPipelineConfigurations,
            inputKey: \ListMediaInsightsPipelineConfigurationsRequest.nextToken,
            outputKey: \ListMediaInsightsPipelineConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMediaInsightsPipelineConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaInsightsPipelineConfigurationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMediaInsightsPipelineConfigurationsRequest, ListMediaInsightsPipelineConfigurationsResponse> {
        let input = ListMediaInsightsPipelineConfigurationsRequest(
            maxResults: maxResults
        )
        return self.listMediaInsightsPipelineConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMediaPipelineKinesisVideoStreamPools(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaPipelineKinesisVideoStreamPoolsPaginator(
        _ input: ListMediaPipelineKinesisVideoStreamPoolsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMediaPipelineKinesisVideoStreamPoolsRequest, ListMediaPipelineKinesisVideoStreamPoolsResponse> {
        return .init(
            input: input,
            command: self.listMediaPipelineKinesisVideoStreamPools,
            inputKey: \ListMediaPipelineKinesisVideoStreamPoolsRequest.nextToken,
            outputKey: \ListMediaPipelineKinesisVideoStreamPoolsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMediaPipelineKinesisVideoStreamPools(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaPipelineKinesisVideoStreamPoolsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMediaPipelineKinesisVideoStreamPoolsRequest, ListMediaPipelineKinesisVideoStreamPoolsResponse> {
        let input = ListMediaPipelineKinesisVideoStreamPoolsRequest(
            maxResults: maxResults
        )
        return self.listMediaPipelineKinesisVideoStreamPoolsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMediaPipelines(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaPipelinesPaginator(
        _ input: ListMediaPipelinesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMediaPipelinesRequest, ListMediaPipelinesResponse> {
        return .init(
            input: input,
            command: self.listMediaPipelines,
            inputKey: \ListMediaPipelinesRequest.nextToken,
            outputKey: \ListMediaPipelinesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMediaPipelines(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Valid Range: 1 - 99.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMediaPipelinesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMediaPipelinesRequest, ListMediaPipelinesResponse> {
        let input = ListMediaPipelinesRequest(
            maxResults: maxResults
        )
        return self.listMediaPipelinesPaginator(input, logger: logger)
    }
}

extension ChimeSDKMediaPipelines.ListMediaCapturePipelinesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ChimeSDKMediaPipelines.ListMediaCapturePipelinesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ChimeSDKMediaPipelines.ListMediaInsightsPipelineConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ChimeSDKMediaPipelines.ListMediaInsightsPipelineConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ChimeSDKMediaPipelines.ListMediaPipelineKinesisVideoStreamPoolsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ChimeSDKMediaPipelines.ListMediaPipelineKinesisVideoStreamPoolsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ChimeSDKMediaPipelines.ListMediaPipelinesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ChimeSDKMediaPipelines.ListMediaPipelinesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
